package com.bmadmin.util;


import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.math.BigDecimal;
import java.text.DateFormat;
import java.text.NumberFormat;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


/**
 * Created by 金玮良 on 2017/4/6 0006.
 */
public class BMUtil {
    /**
     * @return
     */

    public static String getUUID() {
        String result ;
        result = UUID.randomUUID().toString() + UUID.randomUUID().toString();
        result = result.replaceAll("-", "");
        return result;
    }

    public static String getUUID(int time){
        String result ="";
        for(int i=1;i<=time;i++){
            result +=UUID.randomUUID().toString();
        }

        result = result.replaceAll("-", "");
        return result;
    }


    /**
     * 根据中文获取拼音
     * <p>
     * 依赖 maven 包：
     * <p>
     * <dependency>
     * <groupId>com.github.stuxuhai</groupId>
     * <artifactId>jpinyin</artifactId>
     * <version>1.0</version>  最新版本为1.18
     * </dependency>
     *
     * @param src
     * @return
     */



    /**
     * 判断字符串是否为数字
     *
     * @param str
     * @return
     */
    public static boolean isNumber(String str) {
        Pattern pattern = Pattern.compile("[0-9.]*");
        Matcher isNum = pattern.matcher(str);
        if (!isNum.matches()) {
            return false;
        }
        return true;
    }

    public static boolean isNumberDotTwo(String str){
        Pattern pattern = Pattern.compile("^(([1-9]{1}\\d*)|([0]{1}))(\\.(\\d){0,2})?$");
        Matcher isNum = pattern.matcher(str);
        if( !isNum.matches() ){
            return false;
        }
        return true;
    }

    /**
     * 获取当前时间
     * @return
     */
    public static String getNowTimeForString() {
        Date date = new Date();
        DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String time = format.format(date);
        return time;
    }

    /**
     * 根据格式获取当前时间
     * @param format
     * @return
     */
    public static String getNowTimeForString(String format) {
        Date date = new Date();
        DateFormat formatDate = new SimpleDateFormat(format);
        String time = formatDate.format(date);
        return time;
    }



    /**
     * 获取当前月份  并向前推12个月份
     * @return 返回月份
     */

    public static String[] getLast12Months(){

        String[] last12Months = new String[12];

        Calendar cal = Calendar.getInstance();
        cal.set(Calendar.MONTH, cal.get(Calendar.MONTH)+1); //要先+1,才能把本月的算进去
        for(int i=0; i<12; i++){


            if(cal.get(Calendar.MONTH)-i<1){
                last12Months[11-i] = cal.get(Calendar.YEAR)-1+ "-" + fillZero((cal.get(Calendar.MONTH)-i+12*1));
            }else{
                last12Months[11-i] = cal.get(Calendar.YEAR)+ "-" + fillZero((cal.get(Calendar.MONTH)-i));
            }

//            System.out.println(last12Months[11-i]);
        }

        return last12Months;
    }

    /**
     * 此方法为 获取当前月份方法 配套使用方法
     * @param i
     * @return
     */
    public static String fillZero(int i){
        String str="";
        if(i>0&&i<10){
            str = "0"+i;
        }else{
            str=""+i;
        }
        return str;

    }

    /**
     * Purpose:判断一个字符串是否为空
     *
     * @author wojy
     * @param value
     * @return
     */
    public static boolean isNotNull(String value) {
        boolean isNull = false;
        if (value != null && value.trim().length() > 0
                && !"null".equalsIgnoreCase(value)) {
            isNull = true;
        }
        return isNull;
    }

    public static boolean isNullOrEmpty(Object paramObject) {
        return ((paramObject == null) || ("".equals(paramObject.toString())));
    }

    /**
     * wjy 长度20位
     *
     * @return
     */
    public static String getCguid() {
        String rt = "";
        Date dt = new Date();
        SimpleDateFormat date_format = new SimpleDateFormat("yyyyMMddhhmmss");

        rt = date_format.format(dt);
        rt += getRandmonVerifyCode(6);

        return rt;
    }

    /**
     * 生成制定长度验证码
     *
     * @param verifyCode_len
     *            验证码长度
     * @return String
     */
    private synchronized static String getRandmonVerifyCode(int verifyCode_len) {
        char[] c = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' };
        int maxNum = 100;
        int count = 0;// 记录验证码长度

        StringBuffer verifyCodeStr = new StringBuffer();
        Random random = new Random(System.currentTimeMillis());
        while (count < verifyCode_len) {
            int i = random.nextInt(maxNum);
            if (i >= 0 && i < c.length) {
                verifyCodeStr.append(String.valueOf(i));
                count++;
            }
        }
        return verifyCodeStr.toString();
    }

    /**
     * 列表内miniui框架时间转指定时间格式 wojy
     *
     * @param time
     * @return
     */
    public static String getMiniuiCSTTime(String time) {
        if (isNotNull(time)) {
            Date annTime = new Date(time);
            SimpleDateFormat CeshiFmt = new SimpleDateFormat(
                    "yyyy-MM-dd HH:mm:ss");
            TimeZone gmtTime = TimeZone.getTimeZone("GMT-06:00");
            CeshiFmt.setTimeZone(gmtTime);
            time = CeshiFmt.format(annTime);
            return time;
        } else {
            return "";
        }
    }

    /**
     *  列表内miniui框架时间转指定时间格式 wojy
     *
     * @param time
     * @return
     */
    public static String getMiniuiCSTTimeYYYY_MM_DD(String time) {
        if (isNotNull(time)) {
            Date annTime = new Date(time);
            SimpleDateFormat CeshiFmt = new SimpleDateFormat("yyyy-MM-dd");
            TimeZone gmtTime = TimeZone.getTimeZone("GMT-06:00");
            CeshiFmt.setTimeZone(gmtTime);
            time = CeshiFmt.format(annTime);
            return time;
        } else {
            return "";
        }
    }

    /**
     * 查询条件miniui框架时间转指定时间格式 wojy
     *
     * @param time
     * @return
     */
    public static String getMiniuiGMT8Time(String time) {
        if (isNotNull(time)) {
            Date annTime = new Date(time);
            SimpleDateFormat CeshiFmt = new SimpleDateFormat(
                    "yyyy-MM-dd HH:mm:ss");
            TimeZone gmtTime = TimeZone.getTimeZone("GMT+08:00");
            CeshiFmt.setTimeZone(gmtTime);
            time = CeshiFmt.format(annTime);
            return time;
        } else {
            return "";
        }
    }

    /**
     * 查询条件miniui框架时间转指定时间格式 wojy
     *
     * @param time
     * @return
     */
    public static String getMiniuiGMT8TimeYYYY_MM_DD(String time) {
        if (isNotNull(time)) {
            Date annTime = new Date(time);
            SimpleDateFormat CeshiFmt = new SimpleDateFormat(
                    "yyyy-MM-dd");
            TimeZone gmtTime = TimeZone.getTimeZone("GMT+08:00");
            CeshiFmt.setTimeZone(gmtTime);
            time = CeshiFmt.format(annTime);
            return time;
        } else {
            return "";
        }
    }

    /**
     * 把传入的数转换为中文金额大写形式
     *
     * @param flag
     *            int 标志位，1 表示转换整数部分，0 表示转换小数部分
     * @param s
     *            String 要转换的字符串
     * @return 转换好的带单位的中文金额大写形式
     */
    private String numFormat(int flag, String s) {
        int sLength = s.length();
        // 货币大写形式
        String bigLetter[] = { "零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖" };
        // 货币单位
        String unit[] = { "元", "拾", "佰", "仟", "万",
                // 拾万位到仟万位
                "拾", "佰", "仟",
                // 亿位到万亿位
                "亿", "拾", "佰", "仟", "万" };
        String small[] = { "分", "角" };
        // 用来存放转换后的新字符串
        String newS = "";
        // 逐位替换为中文大写形式
        for (int i = 0; i < sLength; i++) {
            if (flag == 1) {
                // 转换整数部分为中文大写形式（带单位）
                newS = newS + bigLetter[s.charAt(i) - 48]
                        + unit[sLength - i - 1];
            } else if (flag == 2) {
                // 转换小数部分（带单位）
                newS = newS + bigLetter[s.charAt(i) - 48]
                        + small[sLength - i - 1];
            }
        }
        return newS;
    }

    public static String HtmlEncode(String theString){
        theString = theString.replaceAll("\n", "\\\\n");
        return theString;
    }

//	    public static String HtmlDiscode(String theString){
//		    theString = theString.replaceAll("&gt;", ">");
//		    theString = theString.replaceAll("&lt;", "<");
//		    theString = theString.replaceAll("&nbsp;", " ");
//		    theString = theString.replaceAll("&quot;", "\"");
//		    theString = theString.replaceAll("&#39;", "\'");
//		    theString = theString.replaceAll("<br/>", "\n");
//		    return theString;
//	    }

    /**
     * 保留两位小数 乘法
     */
    public static String Plus(String val1,String val2){
        NumberFormat nf = NumberFormat.getNumberInstance();
        nf.setMaximumFractionDigits(2);
        BigDecimal bd1 = new BigDecimal(Double.parseDouble(val1));
        BigDecimal bd2 = new BigDecimal(Double.parseDouble(val2));
        BigDecimal num = bd1.multiply(bd2);
        String str = nf.format(num);
        return str;
    }

    //默认除法运算精度
    private static final int DEF_DIV_SCALE = 10;

    /**
     * 提供精确的加法运算。
     * @param v1 被加数
     * @param v2 加数
     * @return 两个参数的和
     */
    public static double add(double v1,double v2)
    {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.add(b2).doubleValue();
    }

    /**
     * 提供精确的减法运算。
     * @param v1 被减数
     * @param v2 减数
     * @return 两个参数的差
     */
    public static double sub(double v1,double v2){
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.subtract(b2).doubleValue();
    }
    /**
     * 提供精确的乘法运算。
     * @param v1 被乘数
     * @param v2 乘数
     * @return 两个参数的积
     */
    public static double mul(double v1,double v2)
    {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.multiply(b2).doubleValue();
    }
    /**
     * 提供（相对）精确的除法运算，当发生除不尽的情况时，精确到
     * 小数点以后10位，以后的数字四舍五入。
     * @param v1 被除数
     * @param v2 除数
     * @return 两个参数的商
     */
    public static double div(double v1,double v2)
    {
        return div(v1,v2,DEF_DIV_SCALE);
    }
    /**
     * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
     * 定精度，以后的数字四舍五入。
     * @param v1 被除数
     * @param v2 除数
     * @param scale 表示表示需要精确到小数点以后几位。
     * @return 两个参数的商
     */
    public static double div(double v1,double v2,int scale)
    {
        if(scale<0)
        {
            throw new IllegalArgumentException("The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.divide(b2,scale,BigDecimal.ROUND_HALF_UP).doubleValue();
    }
    /**
     * 提供精确的小数位四舍五入处理。
     * @param v 需要四舍五入的数字
     * @param scale 小数点后保留几位
     * @return 四舍五入后的结果
     */
    public static double round(double v,int scale)
    {
        if(scale<0)
        {
            throw new IllegalArgumentException("The scale must be a positive integer or zero");
        }
        BigDecimal b = new BigDecimal(Double.toString(v));
        BigDecimal one = new BigDecimal("1");
        return b.divide(one,scale,BigDecimal.ROUND_HALF_UP).doubleValue();
    }
    /**
     * 把null转换成空字符串
     */
    public static String NulltoString(Object o) {
        if (o == null)
            return "";
        return o.toString();
    }
    public static String NulltoZero(Object o) {
        if (o == null)
            return "0";
        if(o.equals(""))
            return "0";
        return o.toString();
    }
    public static String Object2String(Object t){
        if(t == null) return "";
        if("null".equals(String.valueOf(t))) return "";
        return String.valueOf(t);
    }

    public static String getRandomString(int length) { //length表示生成字符串的长度
        String base = "abcdefghijklmnopqrstuvwxyz0123456789";
        Random random = new Random();
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < length; i++) {
            int number = random.nextInt(base.length());
            sb.append(base.charAt(number));
        }
        return sb.toString();
    }


 	/**
 	 * 验证EXCEL文件
 	 * 
 	 * @param filePath
 	 * @return
 	 */
 	public static boolean validateExcel(String filePath) {
 		if (filePath == null
 				|| !(isExcel2003(filePath) || isExcel2007(filePath))) {
 			return false;
 		}
 		return true;
 	}

 	 // @描述：是否是2003的excel，返回true是2003
 	public static boolean isExcel2003(String filePath) {
 		return filePath.matches("^.+\\.(?i)(xls)$");
 	}

 	// @描述：是否是2007的excel，返回true是2007
 	public static boolean isExcel2007(String filePath) {
 		return filePath.matches("^.+\\.(?i)(xlsx)$");
 	}
 	
 	/**
 	   * 验证手机号码
 	   * @param mobiles
 	   * @return
 	   */
	public static boolean checkMobileNumber(String mobileNumber){
		boolean flag = false;
		try{
	        Pattern regex = Pattern.compile("^(((13[0-9])|(15([0-3]|[5-9]))|(17[0-9])|(18[0-9]))\\d{8})|(0\\d{2}-\\d{8})|(0\\d{3}-\\d{7})$");
	        Matcher matcher = regex.matcher(mobileNumber);
	        flag = matcher.matches();
		}catch(Exception e){
			flag = false;
		}
		return flag;
	}
	
    public static void getFile(byte[] bfile, String filePath,String fileName) throws Exception {
        BufferedOutputStream bos = null;
        FileOutputStream fos = null;
        File file = null;
        try {
            File dir = new File(filePath);
            if(!dir.exists()&&dir.isDirectory()){//判断文件目录是否存在
                dir.mkdirs();
            }
            file = new File(filePath+"\\"+fileName);
//            file = new File(filePath+"/"+fileName);
            fos = new FileOutputStream(file);
            bos = new BufferedOutputStream(fos);
            bos.write(bfile);
        } catch (Exception e) {
            e.printStackTrace();
            throw new Exception(e);
        } finally {
            if (bos != null) {
                try {
                    bos.close();
                } catch (IOException e1) {
                    e1.printStackTrace();
                    throw new Exception(e1);
                }
            }
            if (fos != null) {
                try {
                    fos.close();
                } catch (IOException e1) {
                    e1.printStackTrace();
                    throw new Exception(e1);
                }
            }
        }
    }
}
